8.2 Wrapper-Klassen 

Wrapper-Klassen haben in der Java-Welt zwei wichtige Aufgaben:

• Die Datenstrukturen, die in Java Verwendung finden, können nur Objekte aufnehmen. So stellt sich das Problem, wie primitive Datentypen zu diesen Containern hinzugefügt werden können. Die Klassenbibliothek bietet daher für jeden primitiven Datentyp eine entsprechende Wrapper-Klasse (auch »Ummantelungsklasse« oder »Envelope Class« genannt) an. Exemplare dieser Klassen kapseln je einen Wert des zugehörigen primitiven Typs.

• Zusätzlich zu dieser Eigenschaft bieten die Wrapper-Klassen Funktionen zum Zugriff auf den Wert und einige Umwandlungsfunktionen.

Es existieren Wrapper-Klassen zu allen primitiven Datentypen.

Für void, was kein Datentyp ist, existiert die Klasse Void. Sie deklariert nur die Konstante TYPE vom Typ Class<Void> und ist für Reflection interessanter.

Erzeugen von Wrapper-Objekten

Objekte lieferten die Wrapper-Klassen auf zwei Arten: über Konstruktoren oder über statische valueOf()-Methoden. Übergeben werden die primitven Elemente oder auch Strings.

Integer io = new Integer( 29 ); 
io = Integer.valueOf( 30 ); 
Long    lo = new Long( 0xC0B0L ); 
Double  do = new Double( 12.3 );

int i = 12; 
Integer io = new Integer( i ); 
io = new Integer( io.intValue() + 1 ); 
i = io.intValue();

8.2.1 Die Basisklasse Number für numerische Wrapper-Objekte 

Die Wrapper-Klassen für byte, short, int, long, float und double sind Unterklassen der abstrakten Klasse Number. Daher implementieren die Klassen Byte, Short, Integer, Long, Float und Double und ebenfalls BigDecimal und BigInteger die abstrakten Methoden zur Umwandlung in einen speziellen Datentyp aus Number. In Java 5 kommen AtomicInteger und AtomicLong hinzu, die aber nicht immutable sind wie die anderen Klassen.

Die Methodennamen setzen sich aus den Namen des Basistyps und »Value« zusammen. Somit besitzen alle numerischen Wrapper-Klassen Methoden zur Umwandlung in die übrigen numerischen Datentypen.

abstract class java.lang.Number 
implements Serializable

• byte byteValue() Liefert den Wert der Zahl als byte.

• abstract double doubleValue() Liefert den Wert der Zahl als double.

• abstract float floatValue() Liefert den Wert der Zahl als float.

• abstract int intValue() Liefert den Wert der Zahl als int.

• abstract long longValue() Liefert den Wert der Zahl als long.

• short shortValue() Liefert den Wert der Zahl als short.

Nur die Methoden byteValue() und shortValue() sind nicht abstrakt und müssen nicht überschrieben werden. Diese Methoden rufen intValue() auf und konvertieren den Wert über eine Typanpassung auf byte und short.

8.2.2 Die Klasse Integer 

Die Klasse Integer kapselt den Wert einer Ganzzahl vom Typ int in einem Objekt.

Eine Ganzzahl in einen String konvertieren

Die Umwandlung erfolgt mit der statischen toString()-Methode:

int number = 12345; 
String stringNumber = Integer.toString( number );

Zudem lässt sich auch mit der überladenen statischen Funktion String.valueOf() ein int in einen String konvertieren. (Doch nutzt valueOf() intern auch nur Integer.toString(i, 10).)

Ein Java-Idiom zur Konvertierung ist auch folgende Anweisung:

"" + number

int n = 100000; 
String s = NumberFormat.getInstance().format( n );

String in eine Ganzzahl umwandeln

Um aus dem String wieder eine Zahl zu machen, nutzen wir parseInt(), wie schon im String-Kapitel 4 beschrieben. Eine spezialisierte Methode für eine gegebene Basis ist parse-Int(String, int radix). Diese ist gut für Hexadezimalzahlen mit der Basis 16.

Einige Anwendungsfälle:

final class java.lang.Integer 
extends Number 
implements Comparable<Integer>

• static int parseInt( String s ) Erzeugt aus der Zeichenkette die entsprechende Zahl. Die Basis ist 10.

• static int parseInt( String s, int radix ) Erzeugt die Zahl mit der gegebenen Basis. parseInt() nutzt länderspezifische Tausendertrennzeichen nicht.

8.2.3 Unterschiedliche Ausgabeformate 

Neben der toString()-Methode, die eine Zahl als String-Repräsentation im vertrauten Dezimalsystem ausgibt, gibt es noch vier weitere Varianten für die binäre, hexadezimale und oktale Darstellung sowie für die Darstellung einer beliebigen Basis. Die Methoden sind allerdings nicht in der Oberklasse Number deklariert, da nur die Klassen Integer und Long die Methoden implementieren. Alle folgenden Ausgabemethoden sind statisch.

final class Long | Integer 
extends Number 
implements Comparable<Long> | Comparable<Integer>, Serializable

• static String toBinaryString( int | long i ) Erzeugt eine Binärrepräsentation (Basis 2) der vorzeichenlosen Zahl.

• static String toOctalString( int | long i ) Erzeugt eine Oktalzahlrepräsentation (Basis 8) der vorzeichenlosen Zahl.

• static String toHexString( int | long i ) Erzeugt eine Hexadezimalrepräsentation (Basis 16) der vorzeichenlosen Zahl.

• static String toString( int | long i, int radix ) Erzeugt eine String-Repräsentation der Zahl zur angegebenen Basis.

Wir dürfen nicht vergessen, dass das Format der Übergabe int beziehungsweise long ist und nicht byte. Dies führt zu Ausgaben, die einkalkuliert werden müssen. Genauso werden führende Nullen grundsätzlich nicht mit ausgegeben.

Listing 8.1    ToHex.java

class ToHex 
{ 
  public static void main( String[] args ) 
  { 
    System.out.println( "15=" + Integer.toHexString(15) );   // 15=f 
    System.out.println( "16=" + Integer.toHexString(16) );   // 16=10 
    System.out.println( "127=" + Integer.toHexString(127) ); // 127=7f 
    System.out.println( "128=" + Integer.toHexString(128) ); // 128=80 
    System.out.println( "255=" + Integer.toHexString(255) ); // 255=ff 
    System.out.println( "256=" + Integer.toHexString(256) ); // 256=100 
    System.out.println( "-1=" + Integer.toHexString(-1) );   // -1=ffffffff 
  } 
}

8.2.4 Autoboxing: Boxing und Unboxing 

Neu seit Java 5 ist das Autoboxing. [Das dürfte dann die erste Spracheigenschaft sein, die Java von C# übernimmt. Sonst hat C# ja fast alles von Java übernommen. ] Das bedeutet, dass primitive Datentypen und Wrapper-Objekte bei Bedarf ineinander umgewandelt werden. Ein Beispiel:

int i     = 4711; 
Integer j = i;        // steht für  j = Integer.valueOf(i)    (1) 
int k     = j;        // steht für  k = j.intValue()          (2)

Die Anweisung in (1) nennt sich Boxing und erstellt automatisch ein Wrapper-Objekt, sofern es nötig ist. Schreibweise (2) ist das Unboxing und steht für das Beziehen des Elements aus dem Wrapper-Objekt. Das bedeutet: Überall dort, wo der Compiler ein primitives Element erwartet, aber ein Wrapper-Objekt vorhanden ist, entnimmt er den Wert mit einer passenden xxxValue()-Methode aus dem Wrapper.

Der Compiler kann nur dann eine automatische Typanpassung vornehmen, wenn alles zusammenpasst. Sei inc() eine Funktion, die ein neues Integer-Objekt erstellt:

public static Integer inc( Integer i ) 
{ 
  return new Integer( i.intValue() + 1 ); 
}

Die Rückgabe können wir unterschiedlich nutzen:

Object  o1 = inc( 2 ); 
Integer i1 = inc( 2 ); 
int     i2 = inc( 2 ); 
int     i3 = (Integer) inc( 2 );

Alle vier Anweisungen lassen sich übersetzen und sind möglich, da der Compiler weiß, dass die Rückgabe ein Integer ist, was per Unboxing auf den eingebauten Datentyp int konvertiert werden kann. Wenn wir die Funktion ein wenig abändern, sodass sie Object statt Integer liefert, so funktioniert das Autoboxing nicht mehr:

Object  o1 = inc( 2 ); 
Integer i1 = inc( 2 );             // Compilerfehler! 
int     i2 = inc( 2 );             // Compilerfehler! 
int     i3 = (Integer) inc( 2 );

Am angenehmsten ist die Schreibweise dann, wenn etwa in Datenstrukturen primitive Elemente abgelegt werden sollen.

List l = new ArrayList(); 
l.add( Math.sin(Math.PI/4) );

Allerdings warnt der Compiler hier; er wünscht sich eine typisierte Liste, also

List<Double> l = new ArrayList<Double>();

Leider ist es so, dass der Typ der Liste tatsächlich mit dem Wrapper-Typ Double festgelegt werden muss und nicht mit dem Primitivtyp double. Aber vielleicht ändert sich das ja noch irgendwann .

Mehr Probleme als Lösungen?

Mit dem Autoboxing ist eine Reihe von Unregelmäßigkeiten verbunden, die der Programmierer beachten muss, um Fehler zu vermeiden. Eine davon hängt mit dem Unboxing zusammen, das der Compiler immer dann vornimmt, wenn ein Ausdruck einen primitiven Wert erwartet. Wenn kein primitives Element erwartet wird, wird auch kein Unboxing vorgenommen.

Listing 8.2    com/javatutor/insel/lang/Autoboxing.java, Teil 1

package com.javatutor.insel.lang; 
 
class Autoboxing 
{ 
  public static void main( String[] args ) 
  { 
    Integer i1 = new Integer( 1 ); 
    Integer i2 = new Integer( 1 ); 
 
    System.out.println( i1 >= i2 );   // true 
    System.out.println( i1 <= i2 );   // true 
    System.out.println( i1 == i2 );   // false

Der Vergleich mit == ist weiterhin ein Referenzvergleich, und es findet kein Unboxing auf primitive Werte statt, sodass es auf einen Vergleich von primitiven Werten hinausläuft. Daher muss bei zwei unterschiedlichen Integer-Objekten dieser Vergleich immer falsch sein. Das ist natürlich problematisch, da die alte mathematische Regel »aus i <= j und i >= j folgt automatisch i == j« nicht mehr gilt. Wenn es die unterschiedlichen Integer-Objekte für gleiche Werte nicht gäbe, bestünde auch das Problem nicht.

Die Probleme hören aber damit nicht auf. Sun hat versucht, das Problem mit dem == damit zu lösen, dass über Boxing gebildete Integer-Objekte einem Pool entstammen. Da jedoch nicht beliebig viele Objekte aus einem Pool kommen können, gilt die Gleichheit der über Boxing gebildeten Objekte nur in einem ausgewählten Wertebereich zwischen –128 und +127, also dem Wertebereich eines Bytes.

Listing 8.3    com/javatutor/insel/lang/Autoboxing.java, Teil 2

    Integer j1 = 2; 
    Integer j2 = 2; 
    System.out.println( j1 == j2 );   // true 
    Integer k1 = 127; 
    Integer k2 = 127; 
    System.out.println( k1 == k2 );   // true 
    Integer l1 = 128; 
    Integer l2 = 128; 
    System.out.println( l1 == l2 );   // false 
    Integer m1 = 1000; 
    Integer m2 = 1000; 
    System.out.println( m1 == m2 );   // false

Wir haben schon betont, dass auch bei Wrapper-Objekten der Vergleich mit == immer ein Referenz-Vergleich ist. Da 2 und 127 im Wertebereich zwischen –128 und +127 liegen, kommen die entsprechenden Integer-Objekte aus dem Pool. Das gilt für 128 und 1000 nicht; sie sind immer neue Objekte. Damit ergibt auch der ==-Vergleich false.

Es ist interessant zu wissen, was nun genau passiert, wenn Boxing eine Zahl in ein Wrapper-Objekt umwandelt. In diesem Moment wird nicht der Konstruktor aufgerufen, sondern die statische valueOf()-Funktion. Sie kümmert sich auch um das Pooling.

Listing 8.4    com/javatutor/insel/lang/Autoboxing.java, Teil 3

    Integer n1 = new Integer( 10 ); 
    Integer n2 = Integer.valueOf( 10 ); 
    Integer n3 = 10; 
    Integer n4 = 10; 
    System.out.println( n1 == n2 );   // false 
    System.out.println( n2 == n3 );   // true 
    System.out.println( n1 == n3 );   // false 
 
    System.out.println( n3 == n4 );   // true 
  } 
}

Integer i = 1, j = 1; 
boolean b = (i <= j && j <= i && i != j); 
System.out.println( b );

Keine Konvertierung null zu 0

Beim Unboxing führt der Compiler bzw. die Laufzeitumgebung keine Konvertierung von null auf 0 durch. Mit anderen Worten: Bei der folgenden versuchten Zuweisung gibt es eine NullPointerException zur Laufzeit, aber keinen Compilerfehler.

int n = (Integer) null;    // java.lang.NullPointerException

8.2.5 Die Boolean-Klasse 

Die Klasse Boolean kapselt den Datentyp boolean. Sie deklariert zwei Konstanten für die Werte true und false. Es sind Boolean-Objekte, die einmal den Zustand »wahr« und einmal den Zustand »falsch« kodieren.

final class java.lang.Boolean 
implements Serializable, Comparable<Boolean>

• Boolean( boolean value )

• Boolean( String s ) Erzeugt ein neues Boolean-Objekt.

• final static Boolean FALSE

• final static Boolean TRUE Konstanten für Wahrheitswerte. Dazu verwenden wir die statische Methode valueOf().

• static Boolean valueOf( String str ) Parst den String und gibt Boolean.TRUE oder Boolean.FALSE zurück. Die Methode hat gegenüber dem Konstruktor Boolean(boolean) den Vorteil, dass sie immer das gleiche Wahr- oder Falsch-Objekt (Boolean.TRUE oder Boolean.FALSE) zurückgibt, anstatt neue Objekte zu erzeugen. Daher ist es selten nötig, den Konstruktor aufzurufen und neue Boolean-Objekte aufzubauen.

• public static boolean parseBoolean( String s ) Parst den String und liefert entweder true oder false.

Der Konstruktor beziehungsweise valueOf() und parseBoolean() nehmen Strings entgegen, wobei die Groß-/Kleinschreibung unwichtig ist. Die Zeichenfolge muss nur entweder »true« oder »false« sein. So ergibt auch »tRuE« ein Boolean-Objekt mit dem Inhalt true.

8.2.6 Die Klassen Double und Float für Fließkommazahlen 

Die Klassen Double und Float haben wie die anderen Wrapper-Klassen eine Doppelfunktionalität. Sie kapseln zum einen eine Fließkommazahl als Objekt und bieten statische Utility-Funktionen. Wir kommen im Kapitel 5 noch genauer auf die Funktionen zurück.